Add StringSetAccumulator, a Spark accumulator for efficiently tracking
a set of strings across distributed operations. This will be used to
track which Parquet files have been processed during migration.

The accumulator provides:
- Thread-safe add() operation for marking items as processed
- Set-based storage to avoid duplicates
- Proper Spark accumulator semantics for distributed execution

Include comprehensive unit tests covering initialization, adding
elements, merging accumulators, and handling duplicates.

Introduce ParquetProcessingStrategy trait to enable different migration
strategies for Parquet sources. This applies the Strategy pattern to
allow switching between parallel (default) and sequential (with
savepoints) processing modes.

The interface defines a single migrate() method that implementations
will use to execute their specific migration logic.

Implement the parallel processing strategy that reads all Parquet files
at once using Spark's native parquet reader. This is the traditional
approach that maximizes parallelism and performance.

Key characteristics:
- Reads all files in one operation
- No savepoint support (savepointsSupported = false)
- Best performance for migrations expected to complete uninterrupted
- Default behavior matching existing migrations

This strategy maintains backward compatibility with the original
Parquet migration behavior.

Extract ScyllaMigratorBase trait to enable different savepoint
strategies. This refactoring introduces extension points that allow
external savepoints managers to be injected, enabling file-by-file
Parquet migration with savepoints.

Key changes:
- Extract ScyllaMigratorBase trait with template method pattern
- Add externalSavepointsManager hook for injecting custom managers
- Add createSavepointsManager() for strategy-specific manager creation
- Add shouldCloseManager() to control manager lifecycle
- Refactor migrate() to use external or created manager
- Update exception handling to support different accumulator types

The existing ScyllaMigrator object maintains full backward
compatibility by implementing the trait with original CQL savepoints
behavior.

Introduce ScyllaParquetMigrator class to handle Parquet migrations
with external savepoints management. This enables file-by-file
processing where each file's completion is tracked.

Key design decisions:
- Accepts external ParquetSavepointsManager in constructor
- Does not create its own savepoints manager (returns None)
- Does not close the external manager (returns false from
  shouldCloseManager), allowing the caller to manage lifecycle

This separation of concerns allows SequentialParquetStrategy to
orchestrate multiple migrations while maintaining a single savepoints
manager across all file operations.

Implement savepoints manager for tracking processed Parquet files.
Uses StringSetAccumulator to maintain state across Spark operations
and persists the set of processed files to configuration.

Key features:
- Tracks processed files via StringSetAccumulator
- Implements SavepointsManager interface for consistency
- Updates MigratorConfig with skipParquetFiles on state dump
- Factory method initializes accumulator from existing skipParquetFiles

This enables resumable Parquet migrations by remembering which files
have been successfully processed.

Implement sequential Parquet processing strategy that reads and
migrates files one at a time with savepoint support. Each file's
successful migration is recorded before moving to the next.

Key features:
- Processes files sequentially using prepareParquetReader
- Skips already-processed files from skipParquetFiles config
- Uses ParquetSavepointsManager to track progress
- Marks each file as processed after successful migration
- Creates final savepoint when all files complete
- Uses Using.resource for proper manager cleanup

Trade-offs:
- Lower parallelism than parallel mode (processes one file at a time)
- Enables resumability for long-running migrations
- Ideal for large datasets or unreliable environments

Implement utility methods for Parquet file discovery and AWS credential
configuration to support both parallel and sequential processing modes.

New functionality:
- listParquetFiles(): Discovers all Parquet files at given path using
  Spark's recursive file lookup
- prepareParquetReader(): Creates ParquetReaderWithSavepoints that
  filters out already-processed files
- configureHadoopCredentials(): Sets up S3A credentials including
  support for session tokens and regional endpoints

The configureHadoopCredentials method now includes comprehensive
documentation explaining Hadoop's TemporaryAWSCredentialsProvider
requirement and links to official documentation.

These utilities enable the sequential strategy to enumerate files
and track progress while maintaining credential compatibility.

Complete the Strategy pattern implementation by adding strategy
selection logic based on parquetProcessingMode configuration.

The migrateToScylla method now:
- Reads parquetProcessingMode from config.savepoints
- Instantiates ParallelParquetStrategy (default) or
  SequentialParquetStrategy based on mode
- Delegates migration to the selected strategy
- Logs the selected mode for observability

This provides a clean separation between the two migration approaches
while maintaining backward compatibility (parallel is default).

Add comprehensive unit tests for the Parquet savepoints feature:

ParquetSavepointsTest:
- Tests ParquetSavepointsManager state tracking
- Verifies file marking and accumulator behavior
- Tests config update with processed files
- Ensures proper state serialization

ParquetConfigSerializationTest:
- Tests Circe encoding/decoding of ParquetProcessingMode
- Verifies parallel and sequential mode serialization
- Tests Savepoints config with parquetProcessingMode field
- Validates backward compatibility with missing field
- Tests error handling for invalid mode values

These tests ensure configuration serialization and state management
work correctly across migration restarts.

Add integration test suite for end-to-end Parquet migration validation:

ParquetMigratorSuite:
- Base test utilities for Parquet migration testing
- Shared fixtures and helper methods
- Test data generation and validation

ParquetParallelModeTest:
- Integration test for parallel processing mode
- Verifies default behavior and performance characteristics

ParquetSavepointsIntegrationTest:
- Integration test for sequential mode with savepoints
- Tests migration interruption and resumption
- Verifies skipParquetFiles configuration handling
- Validates that already-processed files are skipped
- Ensures data consistency after resume

These tests validate the complete migration flow including Spark
DataFrame operations, ScyllaDB writes, and savepoint persistence.

Add YAML configuration files for testing both Parquet processing modes:

parquet-to-scylla-parallel.yaml:
- Configuration for parallel processing mode (default)
- No parquetProcessingMode specified (uses default)
- Validates backward compatibility

parquet-to-scylla-savepoints.yaml:
- Configuration for sequential processing with savepoints
- Sets parquetProcessingMode: sequential
- Example configuration for resumable migrations

These configurations serve as both test fixtures and documentation
examples for users implementing Parquet migrations.

Simplify ParquetToScyllaBasicMigrationTest to work with the new
Strategy pattern architecture. The test now uses the standard
Parquet migration path which automatically selects the appropriate
strategy based on configuration.

Changes:
- Use Parquet.migrateToScylla instead of direct DataFrame creation
- Remove manual DataFrame construction
- Rely on parallel strategy (default) for basic migration test
- Maintain same test coverage with cleaner implementation

This refactoring validates that the new architecture maintains
backward compatibility with existing migration workflows.

Introduce ParquetProcessingMode enum with two variants:
- Parallel: Process all Parquet files at once (default, no savepoints)
- Sequential: Process files one by one with savepoint support

Add parquetProcessingMode field to Savepoints configuration with
appropriate Circe encoders/decoders. The mode defaults to Parallel
to maintain backward compatibility with existing configurations.

This lays the foundation for implementing savepoint support for
Parquet migrations, allowing users to resume interrupted migrations
without reprocessing already-migrated files.

…la-migrator into parquet-savepoint-rebased